#!/usr/bin/python3
print('------------------------------------')
# 推导式
# Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
# Python 推导式是一种强大且简洁的语法，适用于生成列表、字典、集合和生成器。
# 在使用推导式时，需要注意可读性，尽量保持表达式简洁，以免影响代码的可读性和可维护性。
"""
#### 这么理解：js对象值为一个自定义函数。
let js = {
	day: 1,
	do1: function(){
		return [];
	},
	do2: () => {
		return number;
	}
}
"""

print('# 列表推导式')
print("""
格式：
	[表达式 for 变量 in 列表]
	[out_exp_res for out_exp in input_list]
	或者
	[表达式 for 变量 in 列表 if 条件]
	[out_exp_res for out_exp in input_list if condition]
	
	out_exp_res: 列表生成元素表达式，可以是有返回值的函数
	for out_exp in input_list: 迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中
	if condition: 条件语句，可以过滤列表中不符合条件的值
""")
tuidao_names = ['xiaocao', 'tingting', 'zhangsan', 'wangwu', 'mazi', 'bazi', 'xiaochen', '谭宁', '林志杰', '周杰伦', '黎明', '小鲜肉', '小戏骨']
tuidao_names_lists = [name.capitalize() for name in tuidao_names if len(name)>2]
print("找出字符个数>4的（中文N个字算N个数），然后首字母大写", tuidao_names, tuidao_names_lists)

tuidao_nums = range(1,100)
tuidao_nums_jishu = [i for i in tuidao_nums if i%2!=0]
tuidao_nums_oushu = [i for i in tuidao_nums if i%2==0]
print("计算1~100的奇数：", tuidao_nums_jishu)
print("计算1~100的偶数：", tuidao_nums_oushu)


print('# 字典推导式')
print("""
格式
	{ key_expr: value_expr for value in collection }
	或
	{ key_expr: value_expr for value in collection if condition }
""")
tuidao_dict_nums = [5,6,7,8,9,10]
print("计算每个数字的平方，并作为值。", tuidao_dict_nums, {key: key*key for key in tuidao_dict_nums})
tuidao_dict_ages = [19901023, 19890103, 19860402, 19940816, 19980205, 20000102, 20030504]
print("计算每个人的年龄，并作为值。", tuidao_dict_ages, {age: (2024-int(str(age)[:4])) for age in tuidao_dict_ages})

print('# 集合推导式')
print("""
格式
	{ expression for item in Sequence }
	或
	{ expression for item in Sequence if conditional }
""")
tuidao_set_str = '这是一段文字，我给他变成一段集合'
print(tuidao_set_str, {i for i in tuidao_set_str})
tuidao_set_3 = range(100, 200)
print('把能够被3整除的数字拿出来放到一个集合中：', {i for i in tuidao_set_3 if i%3==0})

print('# 元组推导式（生成器表达式）')



print('# 迭代器与生成器')
print("""
	python最强大的功能之一，是访问集合元素的一种方式
	迭代器是一个可以记住遍历元素位置的对象。
	迭代器对象从第一个元素开始访问，直到全部元素被访问完。迭代器只往前不会后退。
	迭代器两个基本方法： iter(); next();
	字符串、元组、列表都可以创建迭代器对象
""")
iter_list = [23,54,66,88,99]
iter_list_obj = iter(iter_list)
print(next(iter_list_obj))
print(next(iter_list_obj))

print('循环访问迭代器')
while 1:
	try:
		print(next(iter_list_obj))
	except StopIteration:
		print('迭代器对象已经访问完所有元素，跳出循环体')
		break;

# 函数
print('# 函数')
print("""
	函数代码块以def开头，后接函数名和圆括号 `def xxFun():`
	函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
	return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
""")
def sum(a,b):
	a = float(a)
	b = float(b)
	return a + b
print( sum(4, 5), sum(5.3, 9.2), sum('2', 1) )

# php函数方法，给参数加上 & 表示引用
# python中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
# 等同于php的引用，不过python是固定的可变对象

print('	不定长参数， def func(*args); 一个*表示参数以元组形式传入；两个*表示参数以字典形式传入（需遵守key=value结构）')
print('如果单独出现*号，那么*号后边的参数，必须填入关键字？？')
print(' python参数传递，还可以指定形参；如： def func(a,b): ==> func(b=5, a=6)')
def yigeXing(a, *, c = 0, d = 0, e = 0):
	print(a, c, d, e)
yigeXing(4, d=5)

print("""
匿名函数，Python 使用 lambda 来创建匿名函数。
	lambda是一个表达式，函数体比def简单
	lambda是一个表达式，而不是一个代码块
	lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
	可以作为一个参数传到函数体、内置函数中
""")
lambdaFunc1 = lambda a: a * a
print(lambdaFunc1(66))

lambdaFunc2 = lambda arg1, arg2: arg1 * arg2
print(lambdaFunc2(39, 23))

# 装饰器
print("""
装饰器（decorators）
	一种高级功能，允许你动态修改函数或类的行为。
	装饰器是一种函数，接收一个函数作为参数，并返回一个新的函数或原函数
	装饰器的语法使用 @decorator_name 来应用在函数或方法上。
	Python还提供一些内置装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。
""")
# 装饰器的应用场景：
# 	日志记录: 装饰器可用于记录函数的调用信息、参数和返回值。
# 	性能分析: 可以使用装饰器来测量函数的执行时间。
# 	权限控制: 装饰器可用于限制对某些函数的访问权限。
# 	缓存: 装饰器可用于实现函数结果的缓存，以提高性能。

print('# 装饰器函数在日志记录方面的应用；这里可以做测试、调试')
import time
def log_decorators(func):
	def wrapper(*args, **kwargs):
		print(f"装饰器包装体·开始 {func.__name__} at {time.ctime()}")
		return func(*args, **kwargs)
	return wrapper

print('	使用 `@log_decorators` 装饰器函数')
@log_decorators
def add_numbers(a, b):
	return a + b
print(add_numbers(54,98))

print('# 装饰器函数在缓存方面的应用；这里实现一个缓存自定义函数的结果')
cache = {}
def cache_decorators(func):
	def wrapper(args):
		if args in cache:
			print('走缓存了',args)
			return cache[args]
		print('没走缓存',args)
		cache[args] = func(args)
		return cache[args]
	return wrapper

@cache_decorators
def cacheFunc1(a):
	return a
cacheFunc1('aaaa1')
cacheFunc1('aaaa1')
cacheFunc1('bbb')
cacheFunc1('bbb')
print('缓存数据（集合-无序的不重复元素序列）：', cache)

# 装饰器类
print('装饰器类： ？？？？？？')

